Minimum Operations to Make a Uni-Value Grid solution and explanation

def minOperations(grid, x):
    flat_grid = [num for row in grid for num in row]
    flat_grid.sort()

    for i in range(1, len(flat_grid)):
        if (flat_grid[i] - flat_grid[0]) % x != 0:
            return -1
    
    median = flat_grid[len(flat_grid) // 2]
    operations = sum(abs(num - median) // x for num in flat_grid)
    return operations
# Example: minOperations([[2,4],[6,8]], 2) returns 4.

import java.util.*;

public class MinOperations {
    public int minOperations(int[][] grid, int x) {
        List<Integer> flatGrid = new ArrayList<>();
        for (int[] row : grid) {
            for (int num : row) {
                flatGrid.add(num);
            }
        }
        Collections.sort(flatGrid);

        for (int i = 1; i < flatGrid.size(); i++) {
            if ((flatGrid.get(i) - flatGrid.get(0)) % x != 0) return -1;
        }

        int median = flatGrid.get(flatGrid.size() / 2);
        int operations = 0;
        for (int num : flatGrid) {
            operations += Math.abs(num - median) / x;
        }
        return operations;
    }
}
// Test cases and main method omitted.

#include <vector>
#include <algorithm>
#include <cstdlib>
using namespace std;

int minOperations(vector<vector<int>>& grid, int x) {
    vector<int> flatGrid;
    for (const auto& row : grid) {
        for (int val : row) {
            flatGrid.push_back(val);
        }
    }
    sort(flatGrid.begin(), flatGrid.end());

    for (int i = 1; i < flatGrid.size(); ++i) {
        if ((flatGrid[i] - flatGrid[0]) % x != 0) return -1;
    }

    int median = flatGrid[flatGrid.size() / 2];
    int operations = 0;
    for (int num : flatGrid) {
        operations += abs(num - median) / x;
    }
    return operations;
}

// Code for main function and test cases omitted.

function minOperations(grid, x) {
    let flatGrid = [].concat(...grid);
    flatGrid.sort((a, b) => a - b);

    for (let i = 1; i < flatGrid.length; i++) {
        if ((flatGrid[i] - flatGrid[0]) % x !== 0) {
            return -1;
        }
    }

    let median = flatGrid[Math.floor(flatGrid.length / 2)];
    let operations = flatGrid.reduce((acc, num) => acc + Math.abs(num - median) / x, 0);
    return operations;
}
// Example test cases omitted for brevity.

#include <stdio.h>
#include <stdlib.h>

int compare(const void* a, const void* b) {
    return (*(int*)a) - (*(int*)b);
}

int minOperations(int** grid, int m, int n, int x) {
    int* flatGrid = (int*)malloc(m * n * sizeof(int));
    int k = 0;
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            flatGrid[k++] = grid[i][j];
        }
    }
    
    for (int i = 1; i < m * n; ++i) {
        if ((flatGrid[i] - flatGrid[0]) % x != 0) {
            free(flatGrid);
            return -1;
        }
    }
    
    qsort(flatGrid, m * n, sizeof(int), compare);
    int median = flatGrid[(m * n) / 2];
    int operations = 0;
    for (int i = 0; i < m * n; ++i) {
        operations += abs(median - flatGrid[i]) / x;
    }
    
    free(flatGrid);
    return operations;
}

// Main function and test cases omitted for brevity.

using System;
using System.Collections.Generic;
using System.Linq;

public class Solution {
    public int MinOperations(int[][] grid, int x) {
        List<int> flatGrid = grid.SelectMany(row => row).ToList();
        flatGrid.Sort();

        for (int i = 1; i < flatGrid.Count; i++) {
            if ((flatGrid[i] - flatGrid[0]) % x != 0) return -1;
        }

        int median = flatGrid[flatGrid.Count / 2];
        int operations = flatGrid.Sum(num => Math.Abs(num - median) / x);
        return operations;
    }
}
// Test cases and execution omitted.

import java.util.*;

public class MinOperationsDP {
    public int minOperationsDP(int[][] grid, int x) {
        // Infeasible direct use of DP but placeholder illustrating reduced heuristic.
        return -1; // DP is not used due to complexity limitations versus heuristics.
    }
}

#include <math.h>
#include <stdlib.h>
#include <stdio.h>

int minOperationsDP(int** grid, int m, int n, int x) {
    // Placeholder for a more complex dynamic programming approach.
    // The code is abstracted due to inefficacy for m or n conditions without prior heuristics.
    return -1; // Generally not a primary approach with high array conditions.
}

// Placeholder code not utilized due to practicality focus.

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

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
}