How to calculate which current map should be open by a series of map release conditions?

Question

Given four maps open time and their last time(the unit is day):

NAME | AVAILABLE_TIME | LAST_TIME
mapA | 8              | 3
mapB | 11             | 3
mapC | 15             | 3
mapD | 35             | 3

This means:

The 1th day is server open day. 
On 8th day, the mapA becomes available; 
On 11th day, the mapB becomes available;
On 14th day, the mapC becomes  available;
On 35th day , the mapD becomes available;

If any of the map is opened, it will last LAST_TIME days. When the opened map is finished, at 00:00 AM, the system will check if the next map exists and is available, if it is, the system will close the current map and open the next map, otherwise the system will open available maps from the begning.

For example, from 1th day to 7th day, none of the maps is available, thus there's no map to open.

At the 8th day, the mapA becomes available so it would be opened and will last 3 days.

On the 11th day, the system will close mapA and find the next mapB is available now, so it will open mapB. The mapB will last 3 days.

On 14th day, mapB is closed and the system find the next mapC is not available, so it then opens the available maps from the begining, which is to open mapA this day.

On 17th day, the system close mapA and open mapB. On 20th day, mapC becomes opened.

I don't know how to convert the whole process into a method, by entering a number of days and obtaining the map that should be opened on that day. My mind always feels confused when try to code it, especially the cycle that opens the map. Could someone teach me how to code this logic(If you write some code, any language or pseudo code is okay), or just a little bit of thinking is also welcome.

Answer 1

After some thinking, I find a solution:

public class Application {
    public static void main(String[] args) {
        int[] openArr = {8, 11, 15, 35};
        int[] keepArr = {3, 3, 3, 3};
        for (int i = 1; i < 50; i++) {
            System.out.println(i + ": " + getOpenMapIndex(i, openArr, keepArr));
        }
    }

    private static int getOpenMapIndex(int day, int[] openArr, int[] keepArr) {
        int begin = openArr[0];
        int end = openArr[openArr.length - 1];
        if (day < begin) {
            return -1;
        }

        int index = 0;
        int curDay = begin - 1;
        int lastDay = keepArr[index];
        while (curDay != day) {
            curDay++;
            lastDay--;

            if (lastDay == -1) {
                int avaIndex = findFirstLess(openArr, curDay);
                int[] avaArr = Arrays.stream(openArr).limit(avaIndex + 1).toArray();

                if (index + 1 <= avaArr.length - 1) {
                    index++;
                } else {
                    index = 0;
                }
                lastDay = keepArr[index] - 1;

                if (index == 0 && curDay >= end) {
                    int diff = day - curDay;
                    int turn = diff % Arrays.stream(keepArr).sum();
                    int sum = 0;
                    for (int i = 0; i < keepArr.length; i++) {
                        sum += keepArr[i];
                        if (turn < sum) {
                            return i;
                        }
                    }
                }
            }
        }
        return index;
    }


    public static int findFirstLess(int[] sortedArr, int target) {
        if (sortedArr == null || sortedArr.length == 0) {
            return -1;
        }

        if (sortedArr[0] > target) {
            return -1;
        }

        int left = 0, right = sortedArr.length - 1;
        int index = -1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (sortedArr[mid] <= target) {
                index = mid;
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return index;
    }


}