Cyclically Rotating a Grid LeetCode solution in Java

1
class Solution {
2
  public int[][] rotateGrid(int[][] grid, int k) {
3
    int m = grid.length, n = grid[0].length, noOfLayers = Math.min(m / 2, n / 2);
4
    // Peeling each layer one by one
5
    for (int layerNo = 0; layerNo < noOfLayers; layerNo++) {
6
      // Please suggest if you have better way to find perimeter of matrix on a given layer!
7
      int perimeter =
8
          (m - (2 * layerNo))
9
              + (n - (2 * layerNo) - 1)
10
              + (m - (2 * layerNo) - 1)
11
              + (n - (2 * layerNo) - 2);
12
      int[] layer = new int[perimeter]; // this out be use to store that particular layer
13
      readLayer(grid, layer, layerNo, m, n); // this will read the layer
14
      writeLayer(
15
          grid, layer, layerNo, m, n, k); // this will rotate it by k and write back the layer
16
    }
17
    return grid;
18
  }
19

20
  public void readLayer(int[][] grid, int[] layer, int layerNo, int m, int n) {
21
    int count = 0, r = layerNo, c = layerNo;
22
    m--;
23
    n--;
24
    // read left a -> c
25
    for (int i = layerNo; i < n - layerNo; i++) layer[count++] = grid[layerNo][i];
26
    // read down c -> i
27
    for (int i = layerNo; i < m - layerNo; i++) layer[count++] = grid[i][n - layerNo];
28
    // read right i -> g
29
    for (int i = n - layerNo; i > layerNo; i--) layer[count++] = grid[m - layerNo][i];
30
    // read up g -> a
31
    for (int i = m - layerNo; i > layerNo; i--) layer[count++] = grid[i][layerNo];
32
  }
33

34
  public void writeLayer(int[][] grid, int[] layer, int layerNo, int m, int n, int k) {
35
    m--;
36
    n--;
37
    int len = layer.length, count = k;
38
    // write left a -> c
39
    for (int i = layerNo; i < n - layerNo; i++) {
40
      count %= len; // reason if goes out of length start back from 0
41
      grid[layerNo][i] = layer[count++];
42
    }
43
    // write down c -> i
44
    for (int i = layerNo; i < m - layerNo; i++) {
45
      count %= len;
46
      grid[i][n - layerNo] = layer[count++];
47
    }
48
    // write right i -> g
49
    for (int i = n - layerNo; i > layerNo; i--) {
50
      count %= len;
51
      grid[m - layerNo][i] = layer[count++];
52
    }
53
    // write up g -> a
54
    for (int i = m - layerNo; i > layerNo; i--) {
55
      count %= len;
56
      grid[i][layerNo] = layer[count++];
57
    }
58
  }
59
}