Minimum Amount of Time to Fill Cups solution and explanation

def fillCups(amount):
    total = sum(amount)
    max_val = max(amount)
    return max(max_val, (total + 1) // 2)

if __name__ == "__main__":
    amount = [1, 4, 2]
    print(fillCups(amount))

import java.util.*;

public class FillCups {
    public int fillCups(int[] amount) {
        int max = Arrays.stream(amount).max().orElse(0);
        int total = Arrays.stream(amount).sum();
        return Math.max(max, (total + 1) / 2);
    }

    public static void main(String[] args) {
        FillCups fc = new FillCups();
        int[] amount = {1, 4, 2};
        System.out.println(fc.fillCups(amount));
    }
}

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

int fillCups(vector<int>& amount) {
    int max_value = *max_element(amount.begin(), amount.end());
    int total = amount[0] + amount[1] + amount[2];
    return max(max_value, (total + 1) / 2);
}

int main() {
    vector<int> amount = {1, 4, 2};
    cout << fillCups(amount) << endl;
    return 0;
}

function fillCups(amount) {
    const total = amount.reduce((a, b) => a + b, 0);
    const maxVal = Math.max(...amount);
    return Math.max(maxVal, Math.ceil(total / 2));
}

const amount = [1, 4, 2];
console.log(fillCups(amount));

#include <stdio.h>

int fillCups(int* amount, int amountSize) {
    int max = 0, total = 0;
    for (int i = 0; i < amountSize; i++) {
        if (amount[i] > max)
            max = amount[i];
        total += amount[i];
    }
    return total / 2 + total % 2 > max ? total / 2 + total % 2 : max;
}

int main() {
    int amount[] = {1,4,2};
    int result = fillCups(amount, 3);
    printf("%d\n", result);
    return 0;
}

using System;
using System.Linq;

public class FillCupsProblem {
    public int FillCups(int[] amount) {
        int max = amount.Max();
        int total = amount.Sum();
        return Math.Max(max, (total + 1) / 2);
    }

    public static void Main() {
        int[] amount = {1, 4, 2};
        FillCupsProblem fcp = new FillCupsProblem();
        Console.WriteLine(fcp.FillCups(amount));
    }
}

import heapq

def fillCups(amount):
    amount = [-a for a in amount]  # Negate values for max-heap
    heapq.heapify(amount)
    seconds = 0
    while amount[0] < 0:  # Negative largest
        first = heapq.heappop(amount)
        second = heapq.heappop(amount)
        if first < 0: first += 1
        if second < 0: second += 1
        heapq.heappush(amount, first)
        heapq.heappush(amount, second)
        seconds += 1
    return seconds

if __name__ == "__main__":
    amount = [1, 4, 2]
    print(fillCups(amount))

import java.util.*;

public class FillCups {
    public int fillCups(int[] amount) {
        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
        for (int a : amount) pq.add(a);
        int seconds = 0;
        while (pq.peek() > 0) {
            int first = pq.poll();
            int second = pq.poll();
            if (first > 0) first--;
            if (second > 0) second--;
            pq.add(first);
            pq.add(second);
            seconds++;
        }
        return seconds;
    }

    public static void main(String[] args) {
        FillCups fc = new FillCups();
        int[] amount = {1, 4, 2};
        System.out.println(fc.fillCups(amount));
    }
}

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

int fillCups(vector<int>& amount) {
    priority_queue<int> pq(amount.begin(), amount.end());
    int seconds = 0;
    while (pq.top() > 0) {
        int first = pq.top(); pq.pop();
        int second = pq.top(); pq.pop();
        if (first > 0) first--;
        if (second > 0) second--;
        pq.push(first);
        pq.push(second);
        seconds++;
    }
    return seconds;
}

int main() {
    vector<int> amount = {1, 4, 2};
    cout << fillCups(amount) << endl;
    return 0;
}

Max-Heap implementation in JavaScript requires additional boilerplate as JS lacks native heap structures. Using sorting or array manipulations can mimic this but is verbose and not optimal in short examples.

C does not have a built-in priority queue but you can simulate one using manual sorting and/or a custom heap.
This approach is not readily demonstrated in C due to its manual memory management and absence of dynamic arrays or built-in priority queue structures.

using System;
using System.Collections.Generic;

public class FillCupsProblem {
    public int FillCups(int[] amount) {
        PriorityQueue<int, int> pq = new PriorityQueue<int, int>(Comparer<int>.Create((x, y) => y.CompareTo(x)));
        foreach (var a in amount) pq.Enqueue(a, a);
        int seconds = 0;
        while (pq.Peek() > 0) {
            int first = pq.Dequeue();
            int second = pq.Dequeue();
            if (first > 0) first--;
            if (second > 0) second--;
            pq.Enqueue(first, first);
            pq.Enqueue(second, second);
            seconds++;
        }
        return seconds;
    }

    public static void Main() {
        int[] amount = {1, 4, 2};
        FillCupsProblem fcp = new FillCupsProblem();
        Console.WriteLine(fcp.FillCups(amount));
    }
}

function fillCups(amount: number[]): number {
    amount.sort((a, b) => a - b);
    let [a, b, c] = amount;
    let diff = a + b - c;
    if (diff <= 0) return c;
    else return Math.floor((diff + 1) / 2) + c;
}

func fillCups(amount []int) int {
	ans := 0
	for amount[0]+amount[1]+amount[2] > 0 {
		sort.Ints(amount)
		ans++
		amount[2]--
		if amount[1] > 0 {
			amount[1]--
		}
	}
	return ans
}

impl Solution {
    pub fn fill_cups(mut amount: Vec<i32>) -> i32 {
        amount.sort();
        let dif = amount[0] + amount[1] - amount[2];
        if dif <= 0 {
            return amount[2];
        }
        (dif + 1) / 2 + amount[2]
    }
}