1class Solution {
2    // Method to calculate the minimum number of operations needed to write 'Y' on the grid
3    public int minimumOperationsToWriteY(int[][] grid) {
4        int gridSize = grid.length; // Dimension of the grid (since it's n x n)
5      
6        // Arrays to store the count of each number (0, 1, 2) in the regions that form 'Y'
7        int[] countRegionY = new int[3];
8        int[] countOutsideRegionY = new int[3];
9
10        // Loop through each cell in the grid to separate the cells that will form 'Y'
11        // and those that will not
12        for (int i = 0; i < gridSize; ++i) {
13            for (int j = 0; j < gridSize; ++j) {
14                // Conditions to detect cells that are part of 'Y'
15                boolean isDiagonalFromTopLeft = i == j && i <= gridSize / 2;
16                boolean isDiagonalFromTopRight = i + j == gridSize - 1 && i <= gridSize / 2;
17                boolean isVerticalMiddleLine = j == gridSize / 2 && i >= gridSize / 2;
18
19                if (isDiagonalFromTopLeft || isDiagonalFromTopRight || isVerticalMiddleLine) {
20                    // Increment the count for the region that forms 'Y'
21                    ++countRegionY[grid[i][j]];
22                } else {
23                    // Increment the count for the region outside 'Y'
24                    ++countOutsideRegionY[grid[i][j]];
25                }
26            }
27        }
28
29        // We'll assume the worst case where we need to change every cell initially
30        int minOperations = gridSize * gridSize;
31
32        // Evaluate all combinations where the number for region 'Y' and outside are different
33        for (int numberForY = 0; numberForY < 3; ++numberForY) {
34            for (int numberOutsideY = 0; numberOutsideY < 3; ++numberOutsideY) {
35                if (numberForY != numberOutsideY) {
36                    // Calculate the number of operations needed if these two numbers were used
37                    int operations = gridSize * gridSize - countRegionY[numberForY] - countOutsideRegionY[numberOutsideY];
38                    // Check if the current operation count is lower than the minimum found so far
39                    minOperations = Math.min(minOperations, operations);
40                }
41            }
42        }
43
44        // Return the minimum number of operations found
45        return minOperations;
46    }
47}
48

1class Solution {
2public:
3    int minimumOperationsToWriteY(vector<vector<int>>& grid) {
4        int gridSize = grid.size(); // total size of the grid (n x n)
5        int countGroupOne[3] = {0}; // frequency count of numbers in the first group (Y shape)
6        int countGroupTwo[3] = {0}; // frequency count of numbers in the second group (not Y shape)
7      
8        // Iterate through the grid and categorize elements
9        for (int i = 0; i < gridSize; ++i) {
10            for (int j = 0; j < gridSize; ++j) {
11                bool isDiagonalOne = (i == j) && (i <= gridSize / 2); // condition for main diagonal and upper half
12                bool isDiagonalTwo = (i + j == gridSize - 1) && (i <= gridSize / 2); // condition for anti-diagonal and upper half
13                bool isVerticalLine = (j == gridSize / 2) && (i >= gridSize / 2); // condition for the vertical middle line and lower half
14              
15                // Increase the correct frequency counter based on the booleans above
16                if (isDiagonalOne || isDiagonalTwo || isVerticalLine) {
17                    ++countGroupOne[grid[i][j]]; // for Y shape
18                } else {
19                    ++countGroupTwo[grid[i][j]]; // for non-Y shape
20                }
21            }
22        }
23      
24        int minimumOperations = gridSize * gridSize; // maximum number of operations (each cell made to write an element not already in the cell)
25
26        // Find the minimum number of operations by checking all combinations of colours between the groups
27        for (int i = 0; i < 3; ++i) { // iterate over possible colours for group one
28            for (int j = 0; j < 3; ++j) { // iterate over possible colours for group two
29                // Ensure we are not counting the same colour for both groups
30                if (i != j) {
31                    // Calculate operations needed to paint the current combination
32                    // And update minimumOperations if this count is lower
33                    minimumOperations = min(minimumOperations, gridSize * gridSize - countGroupOne[i] - countGroupTwo[j]);
34                }
35            }
36        }
37
38        return minimumOperations; // Return the minimum number of operations found
39    }
40};
41

1/**
2 * Calculates the minimum number of operations to write the integer 'Y'.
3 * 
4 * @param {number[][]} grid - A square grid of numbers.
5 * @return {number} The minimum number of operations to write 'Y'.
6 */
7function minimumOperationsToWriteY(grid: number[][]): number {
8    // Get the size of the grid.
9    const gridSize = grid.length;
10
11    // Initialize counters for the number collections.
12    const crossCounters: number[] = Array(3).fill(0);
13    const otherCounters: number[] = Array(3).fill(0);
14  
15    // Loop through the grid to count occurrences.
16    for (let i = 0; i < gridSize; ++i) {
17        for (let j = 0; j < gridSize; ++j) {
18            // Check if the current cell is part of the cross (Y shape).
19            const onFirstDiagonal = i === j && i <= gridSize >> 1;
20            const onSecondDiagonal = i + j === gridSize - 1 && i <= gridSize >> 1;
21            const onMiddleColumn = j === gridSize >> 1 && i >= gridSize >> 1;
22
23            // Update the corresponding counters based on the cell's position.
24            if (onFirstDiagonal || onSecondDiagonal || onMiddleColumn) {
25                ++crossCounters[grid[i][j]];
26            } else {
27                ++otherCounters[grid[i][j]];
28            }
29        }
30    }
31
32    // Initialize the answer with the maximum possible number of operations.
33    let minimumOperations = gridSize * gridSize;
34
35    // Determine the minimum operations required by trying all combinations of numbers.
36    for (let i = 0; i < 3; ++i) {
37        for (let j = 0; j < 3; ++j) {
38            // We want to use different numbers for the cross and the other cells.
39            if (i !== j) {
40                // Calculate the minimum operations by subtracting the already correct cells.
41                minimumOperations = Math.min(
42                    minimumOperations,
43                    gridSize * gridSize - crossCounters[i] - otherCounters[j]
44                );
45            }
46        }
47    }
48
49    // Return the calculated minimum operations.
50    return minimumOperations;
51}
52