#include <vector> 
#include <algorithm> 

int getMinimumTime(const std::vector<int>& requestedServers, const std::vector<int>& transitionTime) { 
    int n = requestedServers.size(); 
    int m = transitionTime.size(); 
    int min_time = 0; 

    for (int i = 1; i < n; i++) { 
        int current = requestedServers[i] - 1;   
        int previous = requestedServers[i - 1] - 1;   
        int distance = std::min((current - previous + m) % m, (previous - current + m) % m); 
        min_time += distance * transitionTime[previous]; 
    } 
     
    return min_time; 
}

import heapq

class GPUAllocator:
    def __init__(self):
        self.available_gpus = []
        self.max_gpu_id = 10**6
        self.next_gpu_id = 1
        self.add_gpus(self.max_gpu_id)

    def add_gpus(self, count):
        for _ in range(count):
            heapq.heappush(self.available_gpus, self.next_gpu_id)
            self.next_gpu_id += 1

    def smallestUnoccupied(self):
        if not self.available_gpus:
            self.add_gpus(100)
        return self.available_gpus[0] if self.available_gpus else -1

# Example usage
allocator = GPUAllocator()
print(allocator.smallestUnoccupied())
print(allocator.smallestUnoccupied())

from collections import defaultdict

def findOptimalResources(arr, k):
    n = len(arr)
    if k > n:
        return -1
    
    window_sum = 0
    max_sum = 0
    unique_elements = defaultdict(int)
    left = 0
    
    for right in range(n):
        window_sum += arr[right]
        unique_elements[arr[right]] += 1
        

        if right - left + 1 > k:
            window_sum -= arr[left]
            unique_elements[arr[left]] -= 1
            if unique_elements[arr[left]] == 0:
                del unique_elements[arr[left]]
            left += 1

        if right - left + 1 == k and len(unique_elements) == k:
            max_sum = max(max_sum, window_sum)
    
    return max_sum if max_sum != 0 else -1

long eqalize(vector<long>power)
{
  int n = power.size();
  sort(power.begin(), power.end());
  long val = 0;
  if (n % 2 == 1) {
    val = power[n / 2];
  }
  else {
    val = (power[(n - 1) / 2] + power[n / 2]) / 2;
  }
  long res = 0;
  for (long i = 0; i < n; ++i)
  {
    res += abs(power[i] - val);
  }
  return res;
}

SELECT 
    ROUND(
        (COUNT(CASE WHEN polygon_name = 'Adarsh Palm Retreat' THEN 1 END) * 100.0) / 
        COUNT(*),
        2
    ) AS order_share
FROM 
    POLYGON
WHERE 
    order_date = '2020-12-31';

SELECT 
    'within 100' AS BUCKET,
    COUNT(*) AS Orders
FROM cuisine_orders
WHERE item_total <= 100

UNION ALL

SELECT 
    'within 150' AS BUCKET,
    COUNT(*) AS Orders
FROM cuisine_orders
WHERE item_total <= 150

UNION ALL

SELECT 
    'within 200' AS BUCKET,
    COUNT(*) AS Orders
FROM cuisine_orders
WHERE item_total <= 200

ORDER BY BUCKET;

def minMoves(h, w, h1, w1):
    if h1 > h or w1 > w:
        return -1
    moves = 0
    while h > h1:
        h = (h + 1) // 2
        moves += 1 
    while w > w1:
        w = (w + 1) // 2
        moves += 1 
    return moves