We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
  1. Prepare
  2. Algorithms
  3. Implementation
  4. Matrix Layer Rotation
  5. Discussions

Matrix Layer Rotation

Sort by

recency

|

774 Discussions

|

  • wifivop476
     + 0 comments

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

  • mohammed_abrar_1
     + 0 comments

    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();
}

    }

  • yashdeora98294
     + 0 comments

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

  • robertbielicki
     + 0 comments

    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)

  • alex1269
     + 0 comments

    Python implementation within time constraints. The idea is to get a linear list for a given circle and set the starting pointer to where it should be after rotating N times instead of rotating each circle N times. 

    def rotate(matrix: list[list[int]], count: int):
    m = len(matrix)
    n = len(matrix[0])

    # given circle 
    for r in range(min(m, n) // 2):
        max_x = n - r - 1
        max_y = m - r - 1
        # flattening the circle
        circle = (
            # top
            [matrix[r][i] for i in range(r, max_x + 1)] +
            # right
            [matrix[y][max_x] for y in range(r + 1, max_y)] +
            # bottom
            [matrix[max_y][i] for i in range(max_x, r - 1, -1)] + 
            # left
            [matrix[y][r] for y in range(max_y - 1, r, -1)]
        )
        length = len(circle)
        pointer = count % length
        idx = pointer
        
        # top
        for i in range(r, max_x + 1):    
            matrix[r][i] = circle[idx]
            idx = idx + 1 if idx < length - 1 else 0
        
        # right
        for i in range(r + 1, max_y):            
            matrix[i][max_x] = circle[idx]
            idx = idx + 1 if idx < length - 1 else 0
        
        # bottom   
        for i in range(max_x + 1, r, -1):            
            matrix[max_y][i - 1] = circle[idx]
            idx = idx + 1 if idx < length - 1 else 0
        
        # left
        for i in range(max_y, r + 1, -1):            
            matrix[i - 1][r] = circle[idx]
            idx = idx + 1 if idx < length - 1 else 0
    

def matrixRotation(matrix, r):    
    rotate(matrix, r)

    for row in matrix:
        print(*row)