hello everyone

this is my java sol and this it is passing all the tese cases. can anyone give me the suggetion to improve my code public static void printMatrix(List> matrix){ for(int i=0;i> matrix, int r) { // Write your code here int row = matrix.size(); int col = matrix.get(0).size();

for(int k=0;k<Math.min(row, col)/2;k++){
int totalElement = (2*(row-2*k) + 2*(col-2*k))-4;
// System.out.println("total "+totalElement);
int it=r%totalElement;
int i=0+k, j=0+k;

while(it>0){

    int[] tempb = new int[row];
    tempb[i] = matrix.get(i).get(j);
    while(i<row-1-k){
        tempb[i+1] = matrix.get(i+1).get(j);
        matrix.get(i+1).set(j, tempb[i]);
        i++; 
    }

    int[] tempr = new int[col];
    tempr[0] = tempb[i];
    int index=0;
    while(j<col-1-k){
        tempr[index+1] = matrix.get(i).get(j+1);
        matrix.get(i).set(j+1, tempr[index]);
        j++;
        index++;
    }

    int[] tempup = new int[row];
    tempup[0] = tempr[index];
    index=0;
    while(i>=1+k){
        tempup[index+1] = matrix.get(i-1).get(j);
        matrix.get(i-1).set(j, tempup[index]);
        i--;
        index++;
    }

    int[] templ = new int[col];
    templ[0] = tempup[index];
    index=0;
    while(j>=1+k){
        templ[index+1] = matrix.get(i).get(j-1);
        matrix.get(i).set(j-1, templ[index]);
        j--;
        index++;
    }
    it--;
}    
    }

printMatrix(matrix);
}

}

Last 2 for loops were for debugging, you only need the second one for the actual solution, and GrowthMount can help optimize this process.

import java.io.; import java.util.; import java.util.stream.*;

class Result {

public static void matrixRotation(List<List<Integer>> matrix, int r) {
    int m = matrix.size();
    int n = matrix.get(0).size();
    int layers = Math.min(m, n) / 2;

    for (int layer = 0; layer < layers; layer++) {
        List<Integer> elements = new ArrayList<>();

        // Top row
        for (int i = layer; i < n - layer; i++) {
            elements.add(matrix.get(layer).get(i));
        }
        // Right column
        for (int i = layer + 1; i < m - layer - 1; i++) {
            elements.add(matrix.get(i).get(n - layer - 1));
        }
        // Bottom row
        for (int i = n - layer - 1; i >= layer; i--) {
            elements.add(matrix.get(m - layer - 1).get(i));
        }
        // Left column
        for (int i = m - layer - 2; i > layer; i--) {
            elements.add(matrix.get(i).get(layer));
        }

        int len = elements.size();
        int rot = r % len;

        List<Integer> rotated = new ArrayList<>();
        rotated.addAll(elements.subList(rot, len));
        rotated.addAll(elements.subList(0, rot));

        int index = 0;

        // Top row
        for (int i = layer; i < n - layer; i++) {
            matrix.get(layer).set(i, rotated.get(index++));
        }
        // Right column
        for (int i = layer + 1; i < m - layer - 1; i++) {
            matrix.get(i).set(n - layer - 1, rotated.get(index++));
        }
        // Bottom row
        for (int i = n - layer - 1; i >= layer; i--) {
            matrix.get(m - layer - 1).set(i, rotated.get(index++));
        }
        // Left column
        for (int i = m - layer - 2; i > layer; i--) {
            matrix.get(i).set(layer, rotated.get(index++));
        }
    }

    // Print the rotated matrix
    for (List<Integer> row : matrix) {
        System.out.println(row.stream().map(Object::toString).collect(Collectors.joining(" ")));
    }
}

}

public class Solution { public static void main(String[] args) throws IOException { BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

    String[] firstMultipleInput = bufferedReader.readLine().replaceAll("\\s+$", "").split(" ");
    int m = Integer.parseInt(firstMultipleInput[0]);
    int n = Integer.parseInt(firstMultipleInput[1]);
    int r = Integer.parseInt(firstMultipleInput[2]);

    List<List<Integer>> matrix = new ArrayList<>();

    IntStream.range(0, m).forEach(i -> {
        try {
            matrix.add(
                Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))
                    .map(Integer::parseInt)
                    .collect(Collectors.toList())
            );
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
    });

    Result.matrixRotation(matrix, r);

    bufferedReader.close();
}

}

Here is problem solution in python java c++ c and Javascript - https://programmingoneonone.com/hackerrank-matrix-layer-rotation-problem-solution.html

Not great solution, but works

def matrixRotation(matrix: list, r:int) -> None:
    temp_matrix = matrix.copy()
    columns = len(matrix[0])
    rows = len(matrix)
    if columns == 1:
        for l in matrix:
            print(*l)
    else:
        result = [[0 for _ in range(columns)] for _ in range(rows)]
        all_layers = []
        if rows == 1:
            all_layers.append(matrix[0])
        elif rows > 1 and columns == 1:
            all_layers = temp_matrix
        else:
            for _ in range(min(rows, columns) // 2):
                temp, right, left  = [],[],[]
                top = temp_matrix.pop(0)
                bottom = temp_matrix.pop()[::-1]
                for layer in temp_matrix:
                    right.append(layer.pop())
                    left.append(layer.pop(0))
                temp += top + right + bottom  + left[::-1]
                all_layers.append(temp)
                if len(temp_matrix) == 1:
                    all_layers.append(temp_matrix.pop())
        for layer in all_layers:
            try:
                rotation_range = r % len(layer)
            except:
                rotation_range = r
            for _ in range(rotation_range):
                if layer:
                    layer.append(layer.pop(0))
        for i, layer in enumerate(all_layers):
            for idx in range(i, columns - i):
                result[i][idx] = layer.pop(0)
            for idx in range(1+i, (rows -1) - i):
                if len(result[idx]) == i or not layer:
                    continue   
                result[idx][-(1+i)] = layer.pop(0)
            for idx in range(i+1, columns +1 - i):
                try:
                    result[-(1+i)][-idx] = layer.pop(0)
                except:
                    pass
            for idx in range(rows-2-i, i, -1):
                try:
                    result[idx][i] = layer.pop(0)
                except:
                    pass
        for l in result:
            print(*l)