Task Scheduler

class Solution {
public:
    int leastInterval(vector<char>& tasks, int n) {
        int cnt[26] = {0};
        for (char c : tasks) ++cnt[c - 'A'];
        int maxFreq = *max_element(cnt, cnt + 26);
        int ties = count(cnt, cnt + 26, maxFreq);
        return max((int)tasks.size(), (maxFreq - 1) * (n + 1) + ties);
    }
};

func leastInterval(tasks []byte, n int) int {
  cnt := [26]int{}
  for _, c := range tasks {
    cnt[c-'A']++
  }
  maxFreq := 0
  for _, v := range cnt {
    if v > maxFreq {
      maxFreq = v
    }
  }
  ties := 0
  for _, v := range cnt {
    if v == maxFreq {
      ties++
    }
  }
  candidate := (maxFreq-1)*(n+1) + ties
  if len(tasks) > candidate {
    return len(tasks)
  }
  return candidate
}

from collections import Counter
from typing import List

class Solution:
    def leastInterval(self, tasks: List[str], n: int) -> int:
        cnt = Counter(tasks)
        max_freq = max(cnt.values())
        ties = sum(1 for v in cnt.values() if v == max_freq)
        return max(len(tasks), (max_freq - 1) * (n + 1) + ties)

var leastInterval = function(tasks, n) {
    const cnt = new Array(26).fill(0);
    for (const c of tasks) cnt[c.charCodeAt(0) - 65]++;
    const maxFreq = Math.max(...cnt);
    const ties = cnt.filter(v => v === maxFreq).length;
    return Math.max(tasks.length, (maxFreq - 1) * (n + 1) + ties);
};

class Solution {
    public int leastInterval(char[] tasks, int n) {
        int[] cnt = new int[26];
        for (char c : tasks) cnt[c - 'A']++;
        int maxFreq = 0;
        for (int v : cnt) if (v > maxFreq) maxFreq = v;
        int ties = 0;
        for (int v : cnt) if (v == maxFreq) ties++;
        return Math.max(tasks.length, (maxFreq - 1) * (n + 1) + ties);
    }
}

function leastInterval(tasks: string[], n: number): number {
    const cnt: number[] = new Array(26).fill(0);
    for (const c of tasks) cnt[c.charCodeAt(0) - 65]++;
    const maxFreq: number = Math.max(...cnt);
    const ties: number = cnt.filter((v: number) => v === maxFreq).length;
    return Math.max(tasks.length, (maxFreq - 1) * (n + 1) + ties);
}