2033. Minimum Operations to Make a Uni-Value Grid

/**
 * Problem: LeetCode 2033 - Minimum Operations to Make a Uni-Value Grid
 * Difficulty: Medium
 * Language: Java
 * Author: CodeByTushu
 */
import java.util.Arrays;

class Solution {
    public int minOperations(int[][] grid, int x) {
        int m = grid.length;
        int n = grid[0].length;
        int[] vals = new int[m * n];
        int idx = 0;
        int rem = grid[0][0] % x;

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] % x != rem) {
                    return -1;
                }
                vals[idx++] = grid[i][j];
            }
        }

        Arrays.sort(vals);
        int median = vals[vals.length / 2];
        int operations = 0;

        for (int val : vals) {
            operations += Math.abs(val - median) / x;
        }

        return operations;
    }
}

"""
Problem: LeetCode 2033 - Minimum Operations to Make a Uni-Value Grid
Difficulty: Medium
Language: Python
Author: CodeByTushu
"""
from typing import List

class Solution:
    def minOperations(self, grid: List[List[int]], x: int) -> int:
        vals = [val for row in grid for val in row]
        rem = vals[0] % x

        for val in vals:
            if val % x != rem:
                return -1

        vals.sort()
        median = vals[len(vals) // 2]

        return sum(abs(val - median) // x for val in vals)

/**
 * Problem: LeetCode 2033 - Minimum Operations to Make a Uni-Value Grid
 * Difficulty: Medium
 * Language: C++
 * Author: CodeByTushu
 */
#include <vector>
#include <algorithm>
#include <cstdlib>

using namespace std;

class Solution {
public:
    int minOperations(vector<vector<int>>& grid, int x) {
        int m = grid.size();
        int n = grid[0].size();
        vector<int> vals;
        vals.reserve(m * n);
        int rem = grid[0][0] % x;

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] % x != rem) {
                    return -1;
                }
                vals.push_back(grid[i][j]);
            }
        }

        sort(vals.begin(), vals.end());
        int median = vals[vals.size() / 2];
        int operations = 0;

        for (int val : vals) {
            operations += abs(val - median) / x;
        }

        return operations;
    }
};

/**
 * Problem: LeetCode 2033 - Minimum Operations to Make a Uni-Value Grid
 * Difficulty: Medium
 * Language: JavaScript
 * Author: CodeByTushu
 */
/**
 * @param {number[][]} grid
 * @param {number} x
 * @return {number}
 */
var minOperations = function(grid, x) {
    const vals = [];
    const rem = grid[0][0] % x;

    for (let i = 0; i < grid.length; i++) {
        for (let j = 0; j < grid[i].length; j++) {
            if (grid[i][j] % x !== rem) {
                return -1;
            }
            vals.push(grid[i][j]);
        }
    }

    vals.sort((a, b) => a - b);
    const median = vals[Math.floor(vals.length / 2)];
    let operations = 0;

    for (let i = 0; i < vals.length; i++) {
        operations += Math.floor(Math.abs(vals[i] - median) / x);
    }

    return operations;
};