Easy C# solution memory beats 100%
IntuitionThe problem involves finding the servers that handle the maximum number of requests in a load-balancing scenario. Given k servers, each request is assi
# Intuition
The problem involves finding the servers that handle the maximum number of requests in a load-balancing scenario. Given k servers, each request is assigned to the next available server in a round-robin manner. If a server is busy, we look for the next available server in a cyclic fashion.

To solve this, we need:

To track the availability of each server (servers array) by maintaining the time at which it becomes free.
To count how many requests each server has handled (count array).
To iterate through the requests and assign each one to an available server based on the described rules.


# Approach
Input Constraints:

If there are fewer requests than servers (arrival.Length <= k), each request can be handled directly by the first arrival.Length servers.
Otherwise, iterate through all requests and handle assignment.
Server Assignment:

For each request i, calculate its primary server (i % k) where it would ideally go.
If the primary server is busy (servers[serverIndex] > arrival[i]), search for the next available server in a cyclic manner.
Stop searching once a suitable server is found or when all servers have been checked.
Updating Server State:

When a server is chosen, update its servers entry with the new time it will be free (arrival[i] + load[i]).
Increment the count for that server to track the number of requests it has handled.
Find the Busiest Servers:

After processing all requests, find the maximum number of requests handled by any server (maxNumberOfReq).
Collect all servers that handled maxNumberOfReq requests.

# Complexity
- Time complexity:
<!-- Add your time complexity here, e.g. $$O(n)$$ -->

- Space complexity:
<!-- Add your space complexity here, e.g. $$O(n)$$ -->

# Code
```csharp []
public class Solution {
    public IList<int> BusiestServers(int k, int[] arrival, int[] load)
        {
			int[] servers = new int[k];
			int[] count = new int[k];

			if(arrival.Length <= k)
			{
				return Enumerable.Range(0, arrival.Length).ToList();
			}

			for(int i =0; i < arrival.Length; i++)
			{
				int serverIndex = i % k;
				if (servers[serverIndex] <= arrival[i])
				{
					servers[serverIndex] = arrival[i] + load[i];
					count[serverIndex]++;
					continue;
                }

				int _count = 1;
				serverIndex++;
                serverIndex = serverIndex == k ? 0 : serverIndex;

                while (_count < k)
				{
                    if (servers[serverIndex] <= arrival[i])
                    {
                        servers[serverIndex] = arrival[i] + load[i];
                        count[serverIndex]++;
						break;
                    }
					_count++;
					serverIndex++;
                    serverIndex = serverIndex == k ? 0 : serverIndex;
                }
			}

			int maxNumberOfReq = Int32.MinValue;
			IList<int> result = new List<int>();
			for(int i = 0; i < count.Length; i++)
			{
				if (count[i] > maxNumberOfReq)
				{
					maxNumberOfReq = count[i];
					result.Clear();
					result.Add(i);
					continue;
                }

				if (count[i] == maxNumberOfReq)
				{
                    result.Add(i);
                    continue;
                }
			}
			return result;
        }
}
```
['C#']