Minimum Operations to Make the Array Alternating solution and explanation

from collections import Counter

 def minOperations(nums):
     if len(nums) <= 1:
         return 0
     even_count = Counter(nums[0::2])
     odd_count = Counter(nums[1::2])
     most_common_even = even_count.most_common(2) + [(None, 0)] * (2 - len(even_count))
     most_common_odd = odd_count.most_common(2) + [(None, 0)] * (2 - len(odd_count))
     if most_common_even[0][0] != most_common_odd[0][0]:
         return len(nums) - most_common_even[0][1] - most_common_odd[0][1]
     else:
         return len(nums) - max(most_common_even[0][1] + most_common_odd[1][1], most_common_even[1][1] + most_common_odd[0][1])

import java.util.HashMap;
import java.util.Map;

public class Solution {
    public int minOperations(int[] nums) {
        int n = nums.length;
        Map<Integer, Integer> even_count = new HashMap<>();
        Map<Integer, Integer> odd_count = new HashMap<>();
        for (int i = 0; i < n; i++) {
            if (i % 2 == 0) even_count.put(nums[i], even_count.getOrDefault(nums[i], 0) + 1);
            else odd_count.put(nums[i], odd_count.getOrDefault(nums[i], 0) + 1);
        }
        freqs evenFreq = getTopTwo(even_count);
        freqs oddFreq = getTopTwo(odd_count);
        if (evenFreq.num1 != oddFreq.num1) return n - evenFreq.count1 - oddFreq.count1;
        return n - Math.max(evenFreq.count1 + oddFreq.count2, evenFreq.count2 + oddFreq.count1);
    }

    class freqs {
        int num1, count1, num2, count2;
        freqs(int num1, int count1, int num2, int count2) {
            this.num1 = num1;
            this.count1 = count1;
            this.num2 = num2;
            this.count2 = count2;
        }
    }

    private freqs getTopTwo(Map<Integer, Integer> map) {
        int num1 = 0, count1 = 0, num2 = 0, count2 = 0;
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            int num = entry.getKey(), count = entry.getValue();
            if (count > count1) {
                num2 = num1; count2 = count1;
                num1 = num; count1 = count;
            } else if (count > count2) {
                num2 = num; count2 = count;
            }
        }
        return new freqs(num1, count1, num2, count2);
    }
}

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
using namespace std;

int minOperations(vector<int>& nums) {
    int n = nums.size();
    unordered_map<int, int> even_count, odd_count;
    for(int i = 0; i < n; ++i) {
        if (i % 2 == 0) even_count[nums[i]]++;
        else odd_count[nums[i]]++;
    }
    vector<pair<int, int>> even, odd;
    for (auto &p : even_count) even.emplace_back(-p.second, p.first);
    for (auto &p : odd_count) odd.emplace_back(-p.second, p.first);
    even.push_back({0, -1});
    odd.push_back({0, -1});
    sort(even.begin(), even.end());
    sort(odd.begin(), odd.end());
    if(even[0].second != odd[0].second) return (n / 2) - even[0].first + (n - n/2) - odd[0].first;
    return min((n / 2) - even[0].first + (n - n/2) - odd[1].first, (n / 2) - even[1].first + (n - n/2) - odd[0].first);
}

function minOperations(nums) {
    const n = nums.length;
    const even_count = new Map();
    const odd_count = new Map();

    for (let i = 0; i < n; i++) {
        if (i % 2 === 0) even_count.set(nums[i], 1 + (even_count.get(nums[i]) || 0));
        else odd_count.set(nums[i], 1 + (odd_count.get(nums[i]) || 0));
    }

    function getTopTwo(map) {
        const freq = [...map.entries()].sort((a, b) => b[1] - a[1]);
        return [freq[0] || [null, 0], freq[1] || [null, 0]];
    }

    const [evenMax1, evenMax2] = getTopTwo(even_count);
    const [oddMax1, oddMax2] = getTopTwo(odd_count);

    if (evenMax1[0] !== oddMax1[0])
        return n - evenMax1[1] - oddMax1[1];
    return n - Math.max(evenMax1[1] + oddMax2[1], evenMax2[1] + oddMax1[1]);
}

# Placeholder solution, intentionally left blank for uniformity and balance

// Java equivalent operations and constraints logic applied here

// Placeholder implementation, to be adapted considering direct manipulation effects

// Placeholder, bridging function extension over arrays

function minimumOperations(nums: number[]): number {
    const f = (i: number): [number, number, number, number] => {
        const cnt: Map<number, number> = new Map();
        for (; i < nums.length; i += 2) {
            cnt.set(nums[i], (cnt.get(nums[i]) || 0) + 1);
        }

        let [k1, k2] = [0, 0];
        for (const [k, v] of cnt) {
            if ((cnt.get(k1) || 0) < v) {
                k2 = k1;
                k1 = k;
            } else if ((cnt.get(k2) || 0) < v) {
                k2 = k;
            }
        }
        return [k1, cnt.get(k1) || 0, k2, cnt.get(k2) || 0];
    };

    const a = f(0);
    const b = f(1);
    const n = nums.length;
    if (a[0] !== b[0]) {
        return n - (a[1] + b[1]);
    }
    return n - Math.max(a[1] + b[3], a[3] + b[1]);
}

func minimumOperations(nums []int) int {
	f := func(i int) [4]int {
		cnt := make(map[int]int)
		for ; i < len(nums); i += 2 {
			cnt[nums[i]]++
		}

		k1, k2 := 0, 0
		for k, v := range cnt {
			if cnt[k1] < v {
				k2, k1 = k1, k
			} else if cnt[k2] < v {
				k2 = k
			}
		}
		return [4]int{k1, cnt[k1], k2, cnt[k2]}
	}

	a := f(0)
	b := f(1)
	n := len(nums)
	if a[0] != b[0] {
		return n - (a[1] + b[1])
	}
	return n - max(a[1]+b[3], a[3]+b[1])
}