Minimum Operations to Make the Array Alternating LeetCode solution in JavaScript

1
/**
2
 * @param {number[]} nums
3
 * @return {number}
4
 */
5

6
var minimumOperations = function (nums) {
7
  let countOddId = {};
8
  let countEvenId = {};
9
  if (nums.length === 1) return 0;
10
  if (nums.length === 2 && nums[0] === nums[1]) {
11
    return 1;
12
  }
13
  nums.forEach((n, i) => {
14
    if (i % 2) {
15
      if (!countOddId[n]) {
16
        countOddId[n] = 1;
17
      } else {
18
        countOddId[n]++;
19
      }
20
    } else {
21
      if (!countEvenId[n]) {
22
        countEvenId[n] = 1;
23
      } else {
24
        countEvenId[n]++;
25
      }
26
    }
27
  });
28

29
  const sortedEven = Object.entries(countEvenId).sort((a, b) => {
30
    return b[1] - a[1];
31
  });
32

33
  const sortedOdd = Object.entries(countOddId).sort((a, b) => {
34
    return b[1] - a[1];
35
  });
36

37
  if (sortedEven[0][0] === sortedOdd[0][0]) {
38
    let maxFirst = 0;
39
    let maxSec = 0;
40

41
    if (sortedEven.length === 1) {
42
      maxFirst = sortedEven[0][1];
43
      maxSec = sortedOdd[1] ? sortedOdd[1][1] : 0;
44
      return nums.length - (maxFirst + maxSec);
45
    }
46

47
    if (sortedOdd.length === 1) {
48
      maxFirst = sortedOdd[0][1];
49
      maxSec = sortedEven[1] ? sortedEven[1][1] : 0;
50
      return nums.length - (maxFirst + maxSec);
51
    }
52
    if (
53
      sortedEven[0][1] >= sortedOdd[0][1] &&
54
      sortedEven[1][1] <= sortedOdd[1][1]
55
    ) {
56
      maxFirst = sortedEven[0][1];
57
      maxSec = sortedOdd[1][1];
58
      return nums.length - (maxFirst + maxSec);
59
    } else {
60
      maxFirst = sortedOdd[0][1];
61
      maxSec = sortedEven[1][1];
62
      return nums.length - (maxFirst + maxSec);
63
    }
64
  } else {
65
    return nums.length - (sortedEven[0][1] + sortedOdd[0][1]);
66
  }
67
};