Minimum Array Changes to Make Differences Equal solution and explanation

def min_changes(nums, k):
    n = len(nums)
    diff_count = {}
    pair_count = 0

    # Count pair differences
    for i in range(n // 2):
        a, b = nums[i], nums[n - i - 1]
        difference = abs(a - b)
        if difference not in diff_count:
            diff_count[difference] = 0
        diff_count[difference] += 1
        pair_count += 1

    # Find max frequency of a difference
    max_freq = max(diff_count.values()) if diff_count else 0

    return pair_count - max_freq

# Example usage
nums = [0, 1, 2, 3, 3, 6, 5, 4]
k = 6
print(min_changes(nums, k))

import java.util.HashMap;

public class DifferenceSolution {
    public int minChanges(int[] nums, int k) {
        int n = nums.length;
        HashMap<Integer, Integer> diffCount = new HashMap<>();
        int pairCount = 0;

        for (int i = 0; i < n / 2; i++) {
            int a = nums[i];
            int b = nums[n - i - 1];
            int difference = Math.abs(a - b);
            diffCount.put(difference, diffCount.getOrDefault(difference, 0) + 1);
            pairCount++;
        }

        int maxFreq = diffCount.values().stream().max(Integer::compare).orElse(0);
        
        return pairCount - maxFreq;
    }

    public static void main(String[] args) {
        DifferenceSolution sol = new DifferenceSolution();
        int[] nums = {0, 1, 2, 3, 3, 6, 5, 4};
        int k = 6;
        System.out.println(sol.minChanges(nums, k));
    }
}

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>

int minChanges(std::vector<int>& nums, int k) {
    std::vector<int> diff_count(k + 1, 0);
    int pair_count = 0;

    for (int i = 0; i < nums.size() / 2; ++i) {
        int a = nums[i];
        int b = nums[nums.size() - i - 1];
        int difference = std::abs(a - b);
        diff_count[difference]++;
        pair_count++;
    }

    int max_freq = *std::max_element(diff_count.begin(), diff_count.end());
    return pair_count - max_freq;
}

int main() {
    std::vector<int> nums = {0, 1, 2, 3, 3, 6, 5, 4};
    int k = 6;
    std::cout << minChanges(nums, k) << std::endl;
    return 0;
}

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

int minChanges(int* nums, int n, int k) {
    int* diff_count = (int*) calloc(k + 1, sizeof(int));
    int pair_count = 0;
    int max_freq = 0;

    for (int i = 0; i < n / 2; ++i) {
        int a = nums[i];
        int b = nums[n - i - 1];
        int difference = abs(a - b);
        diff_count[difference]++;
        pair_count++;
    }

    for (int i = 0; i <= k; ++i) {
        if (diff_count[i] > max_freq) {
            max_freq = diff_count[i];
        }
    }

    free(diff_count);
    return pair_count - max_freq;
}

int main() {
    int nums[] = {0, 1, 2, 3, 3, 6, 5, 4};
    int n = 8;
    int k = 6;
    printf("%d\n", minChanges(nums, n, k));
    return 0;
}

function minChanges(nums: number[], k: number): number {
    const d: number[] = Array(k + 2).fill(0);
    const n = nums.length;
    for (let i = 0; i < n >> 1; ++i) {
        const x = Math.min(nums[i], nums[n - 1 - i]);
        const y = Math.max(nums[i], nums[n - 1 - i]);
        d[0] += 1;
        d[y - x] -= 1;
        d[y - x + 1] += 1;
        d[Math.max(y, k - x) + 1] -= 1;
        d[Math.max(y, k - x) + 1] += 2;
    }
    let [ans, s] = [n, 0];
    for (const x of d) {
        s += x;
        ans = Math.min(ans, s);
    }
    return ans;
}

func minChanges(nums []int, k int) int {
	d := make([]int, k+2)
	n := len(nums)
	for i := 0; i < n/2; i++ {
		x, y := nums[i], nums[n-1-i]
		if x > y {
			x, y = y, x
		}
		d[0] += 1
		d[y-x] -= 1
		d[y-x+1] += 1
		d[max(y, k-x)+1] -= 1
		d[max(y, k-x)+1] += 2
	}
	ans, s := n, 0
	for _, x := range d {
		s += x
		ans = min(ans, s)
	}
	return ans
}

impl Solution {
    pub fn min_changes(nums: Vec<i32>, k: i32) -> i32 {
        let n = nums.len();
        let mut d = vec![0; (k + 2) as usize];
        for i in 0..n / 2 {
            let x = nums[i].min(nums[n - i - 1]);
            let y = nums[i].max(nums[n - i - 1]);
            d[0] += 1;
            d[(y - x) as usize] -= 1;
            d[(y - x + 1) as usize] += 1;
            let idx = (y.max(k - x) + 1) as usize;
            d[idx] -= 1;
            d[idx] += 2;
        }
        let mut ans = n as i32;
        let mut s = 0;
        for x in d {
            s += x;
            ans = ans.min(s);
        }
        ans
    }
}