Minimum Operations to Make a Uni-Value Grid

// Accepted solution for LeetCode #2033: Minimum Operations to Make a Uni-Value Grid
class Solution {
    public int minOperations(int[][] grid, int x) {
        int m = grid.length, n = grid[0].length;
        int[] nums = new int[m * n];
        int mod = grid[0][0] % x;
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] % x != mod) {
                    return -1;
                }
                nums[i * n + j] = grid[i][j];
            }
        }
        Arrays.sort(nums);
        int mid = nums[nums.length >> 1];
        int ans = 0;
        for (int v : nums) {
            ans += Math.abs(v - mid) / x;
        }
        return ans;
    }
}

// Accepted solution for LeetCode #2033: Minimum Operations to Make a Uni-Value Grid
func minOperations(grid [][]int, x int) int {
	mod := grid[0][0] % x
	nums := []int{}
	for _, row := range grid {
		for _, v := range row {
			if v%x != mod {
				return -1
			}
			nums = append(nums, v)
		}
	}
	sort.Ints(nums)
	mid := nums[len(nums)>>1]
	ans := 0
	for _, v := range nums {
		ans += abs(v-mid) / x
	}
	return ans
}

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

# Accepted solution for LeetCode #2033: Minimum Operations to Make a Uni-Value Grid
class Solution:
    def minOperations(self, grid: List[List[int]], x: int) -> int:
        nums = []
        mod = grid[0][0] % x
        for row in grid:
            for v in row:
                if v % x != mod:
                    return -1
                nums.append(v)
        nums.sort()
        mid = nums[len(nums) >> 1]
        return sum(abs(v - mid) // x for v in nums)

// Accepted solution for LeetCode #2033: Minimum Operations to Make a Uni-Value Grid
/**
 * [2033] Minimum Operations to Make a Uni-Value Grid
 *
 * You are given a 2D integer grid of size m x n and an integer x. In one operation, you can add x to or subtract x from any element in the grid.
 * A uni-value grid is a grid where all the elements of it are equal.
 * Return the minimum number of operations to make the grid uni-value. If it is not possible, return -1.
 *  
 * Example 1:
 * <img alt="" src="https://assets.leetcode.com/uploads/2021/09/21/gridtxt.png" style="width: 164px; height: 165px;" />
 * Input: grid = [[2,4],[6,8]], x = 2
 * Output: 4
 * Explanation: We can make every element equal to 4 by doing the following:
 * - Add x to 2 once.
 * - Subtract x from 6 once.
 * - Subtract x from 8 twice.
 * A total of 4 operations were used.
 *
 * Example 2:
 * <img alt="" src="https://assets.leetcode.com/uploads/2021/09/21/gridtxt-1.png" style="width: 164px; height: 165px;" />
 * Input: grid = [[1,5],[2,3]], x = 1
 * Output: 5
 * Explanation: We can make every element equal to 3.
 *
 * Example 3:
 * <img alt="" src="https://assets.leetcode.com/uploads/2021/09/21/gridtxt-2.png" style="width: 164px; height: 165px;" />
 * Input: grid = [[1,2],[3,4]], x = 2
 * Output: -1
 * Explanation: It is impossible to make every element equal.
 *
 *  
 * Constraints:
 *
 * 	m == grid.length
 * 	n == grid[i].length
 * 	1 <= m, n <= 10^5
 * 	1 <= m * n <= 10^5
 * 	1 <= x, grid[i][j] <= 10^4
 *
 */
pub struct Solution {}

// problem: https://leetcode.com/problems/minimum-operations-to-make-a-uni-value-grid/
// discuss: https://leetcode.com/problems/minimum-operations-to-make-a-uni-value-grid/discuss/?currentPage=1&orderBy=most_votes&query=

// submission codes start here

impl Solution {
    pub fn min_operations(grid: Vec<Vec<i32>>, x: i32) -> i32 {
        0
    }
}

// submission codes end

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    #[ignore]
    fn test_2033_example_1() {
        let grid = vec![vec![2, 4], vec![6, 8]];
        let x = 2;

        let result = 4;

        assert_eq!(Solution::min_operations(grid, x), result);
    }

    #[test]
    #[ignore]
    fn test_2033_example_2() {
        let grid = vec![vec![1, 5], vec![2, 3]];
        let x = 1;

        let result = 5;

        assert_eq!(Solution::min_operations(grid, x), result);
    }

    #[test]
    #[ignore]
    fn test_2033_example_3() {
        let grid = vec![vec![1, 2], vec![3, 4]];
        let x = 2;

        let result = -1;

        assert_eq!(Solution::min_operations(grid, x), result);
    }
}

// Accepted solution for LeetCode #2033: Minimum Operations to Make a Uni-Value Grid
function minOperations(grid: number[][], x: number): number {
    const arr = grid.flat(2);
    arr.sort((a, b) => a - b);
    const median = arr[Math.floor(arr.length / 2)];

    let res = 0;
    for (const val of arr) {
        const c = Math.abs(val - median) / x;
        if (c !== (c | 0)) return -1;
        res += c;
    }

    return res;
}