TaskScheduler.java

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

class TaskScheduler {
    // MIMIC CPU COOLDOWN
    // PriorityQueue<Character> schedule = new PriorityQueue<>();
    ArrayDeque<Character> schedule = new ArrayDeque<>();
    ArrayList<Character> scheduleOrder = new ArrayList<>();

    /*
    Switch to HashMap to avoid positional bias, 
    when you pull from a queue the elements that appear first are select more often.
    */
    public void loadTasksInSchedule(char[] tasks)
    {
        HashMap<Character, Integer> tasksAndFrequency 
        = new HashMap<>();

        for (char x : tasks)
        {
           tasksAndFrequency.put
           (x, tasksAndFrequency.getOrDefault(x, 0) + 1);
        }

        while (!tasksAndFrequency.isEmpty())
        {
            Character target = findMaxFreqencyKey(tasksAndFrequency);

            for (int i = 0; i < tasksAndFrequency.get(target); i++)
            {
                schedule.add(target);
            }

            tasksAndFrequency.remove(target);
        }
    }

    public Character findMaxFreqencyKey(HashMap<Character, Integer> tasksAndFrequency)
    {
        int min = Integer.MAX_VALUE;
        char target = ' ';
        for (Map.Entry<Character, Integer> entry 
        :
        tasksAndFrequency.entrySet())
        {
            int x = entry.getValue(); 
            if (x < min)
            {
                min = x;
                target = entry.getKey();
            }

        }

        return target;
    }

    /*
    Check if the distance between a currently evaluated task and 
    an already evaluated task is less than the limit. 
    E.g. Currently, Eval: A*, Rule: 2, {A, B, C, A*} = true
    */
    public boolean checkIntervalLimitation(Character x, int limit)
    {
        if (scheduleOrder.size() < 1) return true;

        int reach = scheduleOrder.size() - limit;
        if (reach < 0) reach = 0;

        for (int i = scheduleOrder.size() - 1; i >= reach; i--)
        {
            if (x.equals(scheduleOrder.get(i)))
            {
                return false;
            }
        }

        return true;
    }

    public boolean checkScheduleCompletion()
    {
        for (Character x : schedule)
        {
            if(!x.equals('∅')) return false;
        }

        return true;
    }

    public void asdasdasd(int n)
    {
        int elmChecked = 0;
        for (Character elm : schedule)
        {
            elmChecked++;

            if (checkIntervalLimitation(elm, n) 
                && 
            !elm.equals('∅'))
            {
                scheduleOrder.add(elm);
                schedule.remove(elm);
                schedule.add('∅');
                return;
            }

            if (elmChecked == schedule.size())
            {
                scheduleOrder.add('∅');
            } 
        }
    }

    public int runleastInterval(char[] tasks, int n)
    {
        loadTasksInSchedule(tasks);

        while (!checkScheduleCompletion())
        {
            asdasdasd(n);
        }

        int result = scheduleOrder.size();
        scheduleOrder.clear();
        schedule.clear();
        return result;
    }

    public int leastInterval(char[] tasks, int n)
    {
        return runleastInterval(tasks, n);
    }
}

// Unit Tests

class runTaskScheduler
{
    public static void main(String[] args) 
    {
        TaskScheduler ts = new TaskScheduler();

        System.out.println
        (
            ts.leastInterval(new char[]{'A','A','A','B','B','B'}, 2) + " " + //Answer: 8
            ts.leastInterval(new char[]{'A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C', 'D', 'D', 'E'}, 2) + " " + //Answer: 12
            ts.leastInterval(new char[]{'A', 'A', 'B', 'B', 'C', 'C', 'D', 'D', 'E', 'E', 'F', 'F', 'G', 'G', 
            'H', 'H', 'I', 'I', 'J', 'J', 'K', 'K', 'L', 'L', 'M', 'M', 'N', 'N', 'O', 'O', 'P', 'P', 'Q', 'Q', 'R', 'R', 'S', 'S', 'T',
            'T','U','U','V','V','W','W','X','X','Y','Y','Z','Z'}, 2) //Answer: 52
       );
    }
}